package com.itheima.leetcode.od.b.logicalsimulation;

import java.util.Arrays;
import java.util.HashMap;

/**
 * (B卷,100分)- 数据分类（Java & JS & Python）
 * <p>
 * 题目描述
 * <p>
 * 对一个数据a进行分类，分类方法为：
 * <p>
 * 此数据a（四个字节大小）的四个字节相加对一个给定的值b取模，如果得到的结果小于一个给定的值c，则数据a为有效类型，其类型为取模的值；如果得到的结果大于或者等于c，则数据a为无效类型。
 * <p>
 * 比如一个数据a=0x01010101，b=3，按照分类方法计算（0x01+0x01+0x01+0x01）%3=1，
 * <p>
 * 所以如果c=2，则此a为有效类型，其类型为1，如果c=1，则此a为无效类型；
 * <p>
 * 又比如一个数据a=0x01010103，b=3，按照分类方法计算（0x01+0x01+0x01+0x03）%3=0，
 * <p>
 * 所以如果c=2，则此a为有效类型，其类型为0，如果c=0，则此a为无效类型。
 * <p>
 * 输入12个数据，第一个数据为c，第二个数据为b，剩余10个数据为需要分类的数据，
 * <p>
 * 请找到有效类型中包含数据最多的类型，并输出该类型含有多少个数据。
 * <p>
 * 输入描述
 * <p>
 * 输入12个数据，用空格分隔，第一个数据为c，第二个数据为b，剩余10个数据为需要分类的数据。
 * <p>
 * 输出描述
 * <p>
 * 输出最多数据的有效类型有多少个数据。
 * <p>
 * 用例
 * <p>
 * 输入	3 4 256 257 258 259 260 261 262 263 264 265
 * <p>
 * 输出	3
 * <p>
 * 说明
 * 10个数据4个字节相加后的结果分别为1 2 3 4 5 6 7 8 9 10，
 * <p>
 * 故对4取模的结果为1 2 3 0 1 2 3 0 1 2，c为3，所以0 1 2都是有效类型，类型为1和2的有3个数据，类型为0的只有2个数据，故输出3。
 * <p>
 * 输入	1 4 256 257 258 259 260 261 262 263 264 265
 * <p>
 * 输出	2
 * <p>
 * 说明
 * 10个数据4个字节相加后的结果分别为1 2 3 4 5 6 7 8 9 10，
 * <p>
 * 故对4取模的结果为1 2 3 0 1 2 3 0 1 2，c为1，
 * <p>
 * 所以只有0是有效类型，类型为0的有2个数据，故输出2。
 */
public class DataClassification {
    public static void main(String[] args) {
        /*Scanner sc = new Scanner(System.in);

        int c = sc.nextInt();
        int b = sc.nextInt();

        int[] arr = new int[10];
        for (int i = 0; i < 10; i++){
            arr[i] = sc.nextInt();
        }*/

        int[] inputArr = Arrays.stream("3 4 256 257 258 259 260 261 262 263 264 265".split(" "))
                .mapToInt(Integer::parseInt)
                .toArray();

        int c = inputArr[0];
        int b = inputArr[1];
        int length = inputArr.length;

        int[] arr = new int[length - 2];

        System.arraycopy(inputArr, 2, arr, 0, length - 2);

        System.out.println(getResult(c, b, arr));
    }

    // 算法入口
    public static int getResult(int c, int b, int[] arr) {
        HashMap<Integer, Integer> count = new HashMap<>();

        Arrays.stream(arr)
                .map(a -> {
                            String str = Integer.toHexString(a);

                            if (str.length() % 2 != 0) {
                                str = "0" + str;
                            }

                            int sum = 0;
                            for (int i = 0; i < str.length() - 1; i += 2) {
                                sum += Integer.parseInt(str.substring(i, i + 2), 16);
                            }

                            int t = sum % b;
                            if (t < c) {
                                return t;
                            } else {
                                return -1;
                            }
                        }
                )
                .forEach(t -> {
                            if (t != -1) {
                                count.put(t, count.getOrDefault(t, 0) + 1);
                            }
                        }
                );

        return count.values().stream()
                .max((x, y) -> x - y)
                .orElse(0);
    }
}